home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 2 / CU Amiga Magazine's Super CD-ROM 02 (1996)(EMAP Images)(GB)[!][issue 1996-04].iso / magazine / amiga_e / elist.src.archive / 000003_crash!kirk.safb.af.mil!BWILLS_Wed, 9 Jun 93 20:30:15 PST.msg < prev    next >
Text File  |  1993-08-31  |  5KB  |  152 lines
  1. Received: by bkhouse.cts.com (V1.16/Amiga)
  2.     id AA00000; Wed, 9 Jun 93 20:30:15 PST
  3. Received: from kirk.safb.af.mil by crash.cts.com with smtp
  4.     (Smail3.1.28.1 #15) id m0o3awF-0000gxC; Wed, 9 Jun 93 17:56 PDT
  5. Message-Id: <m0o3awF-0000gxC@crash.cts.com>
  6. Date: 9 Jun 93 19:52:00 CST
  7. From: "Barry D. Wills" <BWILLS@kirk.safb.af.mil>
  8. To: "amigae" <amigae@bkhouse.cts.com>
  9. Subject: Linked Lists and Lists
  10.  
  11. This is in response to Son Le's query.  It doesn't really answer your question,
  12. but the three examples I'm posting is what I've learned about lists in E so far.
  13. This is the best I can do for a quick response.  I'll try to come up with some-
  14. thing more relevant.  The distinction between an E list variable and an E linked
  15. list is fairly demonstrated (I think) in this example, where the list variable
  16. contains a sequential collection of like objects (?), and the linked list is a
  17. collection of these things (I like to think of them as nodes) which are linked
  18. together dynamically (whereas the list variable is linked statically, more like
  19. an array.  Wouter, does this make sense?
  20.  
  21. -------------------------------------------------------------------------------
  22.  
  23. ENUM ER_NONE,
  24.      ER_MEM
  25.  
  26.  
  27. RAISE ER_MEM IF List () = NIL
  28.  
  29.  
  30. DEF globalListElement
  31.  
  32.  
  33. PROC print ()
  34.   WriteF (' \d', globalListElement)
  35. ENDPROC
  36.  
  37.  
  38. PROC tailOfList (theList)
  39.   DEF tail
  40.   tail := theList
  41.   WHILE Next (tail) <> NIL DO tail := Next (tail)
  42. ENDPROC  tail
  43.  
  44.  
  45. PROC appendList (theList, listToAppend)
  46.   VOID Link (tailOfList (theList), listToAppend)
  47. ENDPROC
  48.  
  49.  
  50. PROC printAll (theList)
  51.   WriteF ('\n  Contents of list: ')
  52.   readAll (theList, `print ())
  53. ENDPROC
  54.  
  55.  
  56. PROC incrementAll (theList)
  57.   writeAll (theList, `globalListElement + 1)
  58. ENDPROC
  59.  
  60.  
  61. PROC readAll (theList, func)
  62.   DEF link
  63.   link := theList
  64.   WHILE link <> NIL
  65.     ForAll ({globalListElement}, link, func)
  66.     link := Next (link)
  67.   ENDWHILE
  68. ENDPROC
  69.  
  70.  
  71. PROC writeAll (theList, func)
  72.   DEF link
  73.   link := theList
  74.   WHILE link <> NIL
  75.     MapList ({globalListElement}, link, link, func)
  76.     link := Next (link)
  77.   ENDWHILE
  78. ENDPROC
  79.  
  80.  
  81. PROC main () HANDLE
  82.   DEF listHead,
  83.       newListElement,
  84.       counter
  85.  
  86.   /* Allocate and initialize front of list. */
  87.   listHead := List (5)
  88.   FOR counter := 0 TO 4
  89.     ListAdd (listHead, [counter], ALL)
  90.   ENDFOR
  91.  
  92.   /* We now have one list element containing a group of 5 long integers */
  93.   /* which is pointed to by variable listHead.                          */
  94.  
  95.   printAll (listHead)
  96.  
  97.   /* Allocate another list element, initialize it, and append it to the */
  98.   /* end of the list (after listHead and all subsequent Next ()         */
  99.   /* elements, (academic at this point since there is no Next ().)      */
  100.   newListElement := List (5)
  101.   FOR counter := 5 TO 9
  102.     ListAdd (newListElement, [counter], ALL)
  103.   ENDFOR
  104.   appendList (listHead, newListElement)
  105.  
  106.   /* We now have one list element containing a group of 5 long integers   */
  107.   /* which is pointed to by variable listHead, and a Next () element      */
  108.   /* which contains 5 long integers, and which can be accessed by using   */
  109.   /* the internal list function Next () (demonstrated in function         */
  110.   /* readAll () which is called by function printAll ().)  Incidently,    */
  111.   /* the integers can only be accessed by the internal functions          */
  112.   /* ForAll () and MapList () (see functions readAll () and writeAll ().) */
  113.  
  114.   printAll (listHead)
  115.  
  116.   /* Allocate another list element, initialize it, and append it to the   */
  117.   /* end of the list (after listHead and all subsequent Next () elements. */
  118.   newListElement := List (5)
  119.   FOR counter := 10 TO 14
  120.     ListAdd (newListElement, [counter], ALL)
  121.   ENDFOR
  122.   appendList (listHead, newListElement)
  123.  
  124.   /* We now have one list element containing a group of 5 long integers  */
  125.   /* which is pointed to by variable listHead, and two Next () elements  */
  126.   /* each containing 5 long integers, and which can be accessed by using */
  127.   /* the internal list function Next ().                                 */
  128.  
  129.   printAll (listHead)
  130.  
  131.   /* Increment the value in each of the long integers stored in all the */
  132.   /* list elements.                                                     */
  133.   incrementAll (listHead)
  134.  
  135.   printAll (listHead)
  136.  
  137.   DisposeLink (listHead)  /* WARNING!  listHead will be a NIL pointer    */
  138.                           /* after this function call even though it was */
  139.                           /* not allocated using the List () function.   */
  140.  
  141.   WriteF ('\n\n')
  142.   CleanUp (0)
  143.  
  144. EXCEPT
  145.  
  146.   IF exception = ER_MEM THEN WriteF ('\n\n *** Out of memory.\n\n')
  147.  
  148.   CleanUp (exception)
  149.  
  150. ENDPROC
  151.  
  152. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%